home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume3 / uumail < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  54.2 KB
  1. From: genrad!rice!neuro1!sob
  2. Newsgroups: mod.sources
  3. Subject: uumail -- an opath/pathalias based uucp mailer
  4. Approved: jpn@panda.UUCP
  5. Reply-To: sob@neuro1.UUCP (Stan Barber)
  6. Organization: Neurophysiology, Baylor College of Medicine, Houston, Tx
  7.  
  8. Mod.sources:  Volume 3, Issue 49
  9. Submitted by: genrad!rice!neuro1!sob
  10.  
  11.  
  12. Following is the shar for uumail, my version of a pathalias-database
  13. mailer. This program can also understand domain names in the uucp
  14. tradition (! over @) and can handle the new flags in 4.3 uucp.
  15.  
  16. Please read the README for more information.
  17.  
  18. This program has been checked-out on a Sun-2, Masscomp, and Sperry5000.
  19.  
  20. Thanks to Eric Roskos for the use of opath.
  21.  
  22. Please forward comments and bug fixes to me at sob@rice.edu or 
  23. ihnp4!shell!neuro1!sob or texsun!drilltech!sob
  24.  
  25. Stan Barber
  26. Baylor College of Medicine
  27. Houston, Texas
  28.  
  29. #! /bin/sh
  30. # This is a shell archive, meaning:
  31. # 1. Remove everything above the #! /bin/sh line.
  32. # 2. Save the resulting text in a file.
  33. # 3. Execute the file with /bin/sh (not csh) to create the files:
  34. #    README
  35. #    README.orig
  36. #    address.1
  37. #    address.c
  38. #    domains
  39. #    gethostnam.c
  40. #    getpath.c
  41. #    makefile
  42. #    opath.3
  43. #    opath.c
  44. #    palias
  45. #    rmail.c
  46. #    uuconf.h
  47. #    uumail.1
  48. #    uumail.c
  49. #    uupath.1
  50. #    uupath.c
  51. # This archive created: Wed Nov 20 07:16:35 1985
  52. export PATH; PATH=/bin:$PATH
  53. echo shar: extracting "'README'" '(2366 characters)'
  54. if test -f 'README'
  55. then
  56.     echo shar: will not over-write existing file "'README'"
  57. else
  58. sed 's/^X//' << \SHAR_EOF > 'README'
  59. This is an updated version of uumail (and uupath) that can 
  60. access a pathalias-generated database to facilitate routine mail.
  61.  
  62. These program can cope with DBM and standard line-oriented forms of 
  63. pathalias-generated databases.
  64.  
  65. This version of uumail can be used as uupath by linking uumail to
  66. uupath. Also, this version can handle domain addresses (user@host.domain).
  67. You can put as many addresses on a line as you like.
  68.  
  69. There are some compile flags to be aware of when making uumail.
  70. Here is a list of them.
  71.  
  72. DEBUG compiles in the debugging code.
  73. OPATH causes the opath subroutine to be used to resolve addresses.
  74. If you do not use this flag, you cannot use the user@host.domain style
  75. addresses with uumail.
  76. DBM causes uumail to use the DBM format patalias database. If you do not
  77. have the dbm libraries, do not use this flag.
  78. XSYSIII will make adjustments for system that are derived from UNIX System
  79. III or System V.
  80. NOGRADE should be used if your uux does not understand the -g flag.
  81. NORETURN should be used if your uux does not understand the -a flag.
  82. LOG will enable logging of uumail traffic.
  83. UGLYUUCP causes the From_ line produced by uumail to contain the
  84. "remote from hostname" string.
  85. GETHOSTNAME will cause the c-library gethostname to be used. If you
  86. are a BSD site, define this.
  87. XSYSTEMNAME will cause the systemname to be derived from the file
  88. /usr/lib/uucp/SYSTEMNAME. This should be defined if your machine
  89. is a Sperry 5000.
  90.  
  91.  
  92. Here is the mailer segment of a sendmail configuration file that you
  93. can use to define the uumail program as a mailer.
  94. -------------------------------------------------------------------
  95. ############################################################
  96. #### This is a special mailer that takes advantage of    ###
  97. #### usemap database for addresses to UUCP sites         ###
  98. ############################################################
  99.  
  100. Muumail, P=/usr/lib/uucp/uumail,F=sDFhuUM,S=13,R=23,M=1000000,
  101.     A=uumail -h -gC -f$g $h!$u
  102. --------------------------------------------------------------
  103. Please be sure that the S= and R= rules are correct for your
  104. system. They should match the uucp mailer rules exactly.
  105.  
  106. A manual page for uumail and uupath are included.
  107.  
  108. Please forward comments and bug fixes to me at sob@rice.edu or 
  109. ihnp4!shell!neuro1!sob or texsun!drilltech!sob
  110.  
  111. XStan Barber
  112. Baylor College of Medicine
  113. Houston, Texas
  114. SHAR_EOF
  115. if test 2366 -ne "`wc -c < 'README'`"
  116. then
  117.     echo shar: error transmitting "'README'" '(should have been 2366 characters)'
  118. fi
  119. fi # end of overwriting check
  120. echo shar: extracting "'README.orig'" '(875 characters)'
  121. if test -f 'README.orig'
  122. then
  123.     echo shar: will not over-write existing file "'README.orig'"
  124. else
  125. sed 's/^X//' << \SHAR_EOF > 'README.orig'
  126. The makefile can make two programs.  One is a filter that can be used
  127. to expand network paths.  To install it you rename the program that you
  128. want filtered.  The new file name is simply the old one with a period (.) 
  129. appended to the end.  The filter program (filter) is then renamed to the 
  130. original name of the program to be filtered.
  131.     ie mail druxn!kak gets converted to
  132.     mail. pur-ee!decvax!...!druxn!kak
  133.  
  134. The second file the makefile makes is uupath.  This will tell you the network
  135. paths of its arguments
  136. name tell you the path to it.
  137.  
  138. Don't forget to modify the defines for the location of the network map.  The
  139. default location is /etc/usemap
  140.  
  141. If you have any questions just ask.
  142.  
  143.             Jeff Donnelly  (217) 333-6106
  144.             University of Illinois
  145.             pur-ee!uiucdcs!donnelly
  146.  
  147. Jeff may not help much -- his new number is 217-333-7937;
  148. Kolstad can help some also:  214-669-3700
  149. SHAR_EOF
  150. if test 875 -ne "`wc -c < 'README.orig'`"
  151. then
  152.     echo shar: error transmitting "'README.orig'" '(should have been 875 characters)'
  153. fi
  154. fi # end of overwriting check
  155. echo shar: extracting "'address.1'" '(3563 characters)'
  156. if test -f 'address.1'
  157. then
  158.     echo shar: will not over-write existing file "'address.1'"
  159. else
  160. sed 's/^X//' << \SHAR_EOF > 'address.1'
  161. X.TH ADDRESS 1 local
  162. X.SH NAME
  163. address - display the path generated by \fBdeliver\fR for an
  164. RFC822-format address.
  165. X.SH SYNOPSIS
  166. address rfc-address [ ... ]
  167. X.SH DESCRIPTION
  168. This program allows you to check the UUCP mail routing path that will
  169. be generated by the UUCP mailer \fBdeliver\fR if you specify an
  170. RFC822-format address \fBrfc-address\fR in the ``To:'' field of the mail header.
  171. XFor each RFC-style address on the command line, \fBaddress\fR echoes the
  172. address to the standard output, followed by a colon, followed by
  173. the UUCP address that will be used to send the message to that address.
  174.  
  175. X.SH "ADDRESS FORMAT"
  176. Briefly, the RFC822-format address is of the form
  177. X.nf
  178. X.sp 1
  179.     <localaddress>@<hostname>.<network>
  180. X.sp 1
  181. X.fi
  182. where <hostname> is the name of the system you are sending the message
  183. to, <network> is a modifier for <hostname> identifying the network in
  184. which the address is to be interpreted (UUCP, ARPA, MAILNET, CSNET, etc);
  185. and <localaddress> is an address string to be interpreted on the host
  186. machine.
  187.  
  188. The <localaddress> field may contain further remote addresses to be
  189. interpreted on the host machine.  Typically this will be an address for
  190. mailing via another network; and in particular, the <localaddress> may
  191. (recursively) be identical in format to the RFC address, but with
  192. the symbol `%' replacing the symbol `@' in the standard address format.
  193. Where this form is used, the rightmost % is replaced by an
  194. @ before the host machine sends the message out.
  195.  
  196. On our system, the presently
  197. valid <network>s are UUCP, ARPA, CSNET, and MAILNET.
  198. The recently proposed UUCP domain names are also accepted, although
  199. they are treated the same as plain ``UUCP''.
  200. Omitting
  201. the <network> causes the network to default to UUCP.  The <hostname>
  202. should be the name of a remote machine to which the message is
  203. directed; see \fI/usr/lib/uucp/uuaddress.alpha\fR for a list of all
  204. known UUCP hostnames.  It is \fInot\fR necessary to specify a UUCP pathname
  205. when using this format; the pathname is automatically determined for you
  206. and substituted into the address before mailing.  The selected pathname
  207. is determined using the \fBpathalias\fR database, and is supposed
  208. to be optimal, taking into consideration information provided by
  209. each site about how often they send mail out, etc.
  210.  
  211. X.SH EXAMPLES
  212. X.HP 5
  213. joe
  214. X.br
  215. The message is sent to the user ``joe'' on the local system.
  216. X.HP 5
  217. joe@ucbvax
  218. X.br
  219. The message is sent to joe on the UUCP system named ``ucbvax''; this
  220. address is automatically translated to a proper (and ostensibly
  221. optimal) UUCP path.
  222. X.HP 5
  223. joe@ucbvax.UUCP
  224. X.br
  225. XSame as joe@ucbvax
  226. X.HP 5
  227. joe@ucbvax.ARPA
  228. X.br
  229. The message is addressed to joe at ucbvax, using the ARPA network.
  230. The message will be routed to the ARPAnet via a UUCP-ARPAnet gateway.
  231. X.HP 5
  232. joe%mit-multics.ARPA@ucbvax
  233. X.br
  234. The message is sent to ucbvax, who then uses the address
  235. joe@mit-multics.ARPA to send the message on to mit-multics via the
  236. ARPAnet.  Since ucbvax is on the arpanet, this address will work correctly
  237. (as long as there is someone named joe on the MIT multics machine).
  238. X.HP 5
  239. joe%vanderbilt.MAILNET%mit-multics.ARPA@ucbvax
  240. X.br
  241. The message is sent via UUCP to ucbvax, who then sends the message
  242. to mit-multics via the arpanet; mit-multics then sends the message
  243. to joe@vanderbilt via MAILNET.  Since the above machines each have access
  244. to the networks named in the address, this address will work correctly.
  245. X.SH FILES
  246. /usr/lib/uucp/domains - Domain/gateway table
  247. X.br
  248. /usr/lib/uucp/archive - Pathalias database
  249. X.SH "SEE ALSO"
  250. opath(3)
  251. X.SH AUTHOR
  252. Eric Roskos, PE SDC, 1/16/85
  253. SHAR_EOF
  254. if test 3563 -ne "`wc -c < 'address.1'`"
  255. then
  256.     echo shar: error transmitting "'address.1'" '(should have been 3563 characters)'
  257. fi
  258. fi # end of overwriting check
  259. echo shar: extracting "'address.c'" '(885 characters)'
  260. if test -f 'address.c'
  261. then
  262.     echo shar: will not over-write existing file "'address.c'"
  263. else
  264. sed 's/^X//' << \SHAR_EOF > 'address.c'
  265. /*
  266.  * address - run opath to see what a translated RFC822 address will come
  267.  * out as.
  268.  *
  269.  * By E. Roskos 1/16/85
  270.  * $Log:    address.c,v $
  271.  * Revision 1.2  85/09/16  18:31:53  sob
  272.  * Added DEBUG flag
  273.  * 
  274.  * Revision 1.1  85/09/16  17:50:24  sob
  275.  * Initial revision
  276.  * 
  277.  */
  278. #define _DEFINE
  279. #include "uuconf.h"
  280.  
  281. static char rcsid[] = "$Header: address.c,v 1.2 85/09/16 18:31:53 sob Exp $";
  282.  
  283. char *opath();
  284. int Debug;
  285.  
  286. main(argc,argv)
  287. int argc;
  288. char **argv;
  289. {
  290. char *p;
  291. int uswitch;
  292.  
  293.     if (argc < 2)
  294.     {
  295.         fprintf(stderr,"usage: %s rfcaddress [...]\n",
  296.             argv[0]);
  297.         exit(1);
  298.     }
  299.  
  300.     while (--argc)
  301.     {
  302.         p = *++argv;
  303.         if (*p=='-')
  304.         {
  305.             switch(*++p)
  306.             {
  307.             case 'u': uswitch++;
  308.                   continue;
  309.             case 'd': Debug++;
  310.                       continue;
  311.             default:  printf("unknown switch: %c\n",*p);
  312.                   continue;
  313.             }
  314.             continue;
  315.         }
  316.         printf("%s: %s\n",p,uswitch?oupath(p):opath(p));
  317.     }
  318.  
  319.     exit(0);
  320. }
  321. SHAR_EOF
  322. if test 885 -ne "`wc -c < 'address.c'`"
  323. then
  324.     echo shar: error transmitting "'address.c'" '(should have been 885 characters)'
  325. fi
  326. fi # end of overwriting check
  327. echo shar: extracting "'domains'" '(1093 characters)'
  328. if test -f 'domains'
  329. then
  330.     echo shar: will not over-write existing file "'domains'"
  331. else
  332. sed 's/^X//' << \SHAR_EOF > 'domains'
  333. #
  334. # Domain Table
  335. #
  336. # Format: <domain>,<prefix>,<suffix>,<template>
  337. #
  338. # Where <template> may contain:
  339. #       %P - prefix string
  340. #       %S - suffix string
  341. #       %U - destination user name
  342. #       %N - destination site name
  343. #       %D - destination site name with domain suffix
  344. #       %% - a percent (%) sign
  345. #       %R - pathalias route to the destination site
  346. #
  347. X.WA.UUCP,,,%R!%U
  348. X.OR.UUCP,,,%R!%U
  349. X.N-CA.UUCP,,,%R!%U
  350. X.S-CA.UUCP,,,%R!%U
  351. X.MTN.UUCP,,,%R!%U
  352. X.S-CEN.UUCP,,,%R!%U
  353. X.MID-W.UUCP,,,%R!%U
  354. X.S-EAST.UUCP,,,%R!%U
  355. X.ATL.UUCP,,,%R!%U
  356. X.N-ENG.UUCP,,,%R!%U
  357. X.HI.UUCP,,,%R!%U
  358. X.W-CAN.UUCP,,,%R!%U
  359. X.E-CAN.UUCP,,,%R!%U
  360. X.EUR.UUCP,,,%R!%U
  361. X.UK.UUCP,,,%R!%U
  362. X.AUS.UUCP,,,%R!%U
  363. X.ISRAEL.UUCP,,,%R!%U
  364. X.ATT.UUCP,>ihnp4,,%P!%D!%U
  365. X.HP.UUCP,,,%R!%U
  366. X.PE.UUCP,,,%R!%U
  367. X.UUCP,,,%R!%U
  368. X.CSNET,>rice,,%P!%U%%%D@CSNET-RELAY.ARPA
  369. X.MAILNET,>rice,,%P!%U%%%D@MULTICS.MIT.EDU
  370. # .BITNET,>rice,,%P!%U%%%D@WISCVM.ARPA
  371. X.XEROX,>rice,,%P!%U.%D@XEROX.ARPA
  372. X.DEC,>decwrl,,%P!%U@%D
  373. X.ARPA,>rice,,%P!%U@%D
  374. X.EDU,>rice,,%P!%U@%D
  375. X.COM,>rice,,%P!%U@%D
  376. X.GOV,>rice,,%P!%U@%D
  377. X.MIL,>rice,,%P!%U@%D
  378. X.OTH,>rice,,%P!%U@%D
  379. X.BITNET,>psuvax,,%P!%U@%D
  380. SHAR_EOF
  381. if test 1093 -ne "`wc -c < 'domains'`"
  382. then
  383.     echo shar: error transmitting "'domains'" '(should have been 1093 characters)'
  384. fi
  385. fi # end of overwriting check
  386. echo shar: extracting "'gethostnam.c'" '(1266 characters)'
  387. if test -f 'gethostnam.c'
  388. then
  389.     echo shar: will not over-write existing file "'gethostnam.c'"
  390. else
  391. sed 's/^X//' << \SHAR_EOF > 'gethostnam.c'
  392. #ifndef lint
  393. static char    sccsid[] = "@(#)gethostnam.c    6.1 (down!honey) 85/01/21";
  394. static char    rcsid[] = "$Header: gethostnam.c,v 6.2 85/08/03 00:25:16 UUCP Exp $";
  395. #endif lint
  396.  
  397. #ifndef GETHOSTNAME
  398. #include "uuconf.h"
  399.  
  400. void
  401. gethostname(name, len)
  402. char    *name;
  403. {
  404.     FILE    *whoami, *fopen(), *popen();
  405.     char    *ptr, *index();
  406. #ifdef SYSIII
  407.     struct utsname utsn;
  408. #endif
  409.  
  410.     *name = '\0';
  411. #ifdef SYSIII
  412.     if (uname(&utsn) != -1)
  413.     {
  414.         strcpy(name,utsn.nodename);
  415.         len = strlen(name);
  416.           return;
  417.     }
  418. #endif
  419.  
  420.     /* try /etc/whoami */
  421.     if ((whoami = fopen("/etc/whoami", "r")) != 0) {
  422.         (void) fgets(name, len, whoami);
  423.         (void) fclose(whoami);
  424.         if ((ptr = index(name, '\n')) != 0)
  425.             *ptr = '\0';
  426.     }
  427.     if (*name)
  428.         return;
  429.  
  430.     /* try /usr/include/whoami.h */
  431.     if ((whoami = fopen("/usr/include/whoami.h", "r")) != 0) {
  432.         while (!feof(whoami)) {
  433.             char    buf[100];
  434.  
  435.             if (fgets(buf, 100, whoami) == 0)
  436.                 break;
  437.             if (sscanf(buf, "#define sysname \"%[^\"]\"", name))
  438.                 break;
  439.         }
  440.         (void) fclose(whoami);
  441.         if (*name)
  442.             return;
  443.     }
  444.  
  445.     /* ask uucp */
  446.     if ((whoami = popen("uuname -l", "r")) != 0) {
  447.         (void) fgets(name, len, whoami);
  448.         (void) pclose(whoami);
  449.         if ((ptr = index(name, '\n')) != 0)
  450.             *ptr = '\0';
  451.     }
  452.     if (*name)
  453.         return;
  454.     
  455.     /* failure */
  456.     return;
  457. }
  458. #endif GETHOSTNAME
  459. SHAR_EOF
  460. if test 1266 -ne "`wc -c < 'gethostnam.c'`"
  461. then
  462.     echo shar: error transmitting "'gethostnam.c'" '(should have been 1266 characters)'
  463. fi
  464. fi # end of overwriting check
  465. echo shar: extracting "'getpath.c'" '(2798 characters)'
  466. if test -f 'getpath.c'
  467. then
  468.     echo shar: will not over-write existing file "'getpath.c'"
  469. else
  470. sed 's/^X//' << \SHAR_EOF > 'getpath.c'
  471. /*
  472.  * Name: getpath -- return the full usenet path of the given name
  473.  *
  474.  * Paramaters: sysname (input) -- The system name to be expanded
  475.  *           pathname (output)  The usenet path of the given system name
  476.  *           pathfile (input) the file to search for the system name
  477.  *
  478.  * Returns: EX_OK     -- path found
  479.  *        EX_NOHOST -- path not found
  480.  *        EX_NOINPUT-- unable to open usemap
  481.  *
  482.  * Author: J. Donnelly   3/82
  483.  *
  484.  */
  485.  
  486. /* 22-jun-83 Sheppard
  487.  * modified to rewind path file (if open), rather than open again
  488.  *
  489.  * $Log:    getpath.c,v $
  490.  * Revision 1.9  85/11/14  20:21:49  sob
  491.  * Added #ifdef DEBUG to allow compilation without DEBUG
  492.  * 
  493.  * Revision 1.8  85/11/08  03:04:49  sob
  494.  * release version
  495.  * 
  496.  * Revision 1.7  85/09/30  02:47:40  sob
  497.  * Altered to use path filename from global variable.
  498.  * 
  499.  * Revision 1.6  85/08/03  00:48:57  UUCP
  500.  * Cleaned up with lint.
  501.  * Stan Barber
  502.  * 
  503.  * Revision 1.5  85/07/19  17:45:13  UUCP
  504.  * Added \t as a valid seperation character for the database
  505.  * in the non DBM case. This is what pathalias uses.
  506.  * 
  507.  * Revision 1.4  85/07/19  16:44:07  UUCP
  508.  * revised to return proper things in accordance with sysexits
  509.  * Stan
  510.  * 
  511.  * Revision 1.3  85/07/11  19:30:31  sob
  512.  * added "uuconf.h" include file and deleted duplicated information
  513.  * 
  514.  * Revision 1.2  85/07/10  18:30:59  sob
  515.  * updated to add DBM capabilities
  516.  * Stan Barber, Baylor College of Medicine
  517.  * 
  518.  * Revision 1.1  85/07/10  18:03:28  sob
  519.  * Initial revision
  520.  * 
  521.  */
  522.  
  523. #include    "uuconf.h"
  524.  
  525. static char rcsid[] = "$Header: getpath.c,v 1.9 85/11/14 20:21:49 sob Exp $";
  526.  
  527.  
  528.  
  529. XFILE * fopen (), *in;
  530.  
  531. getpath (sysname, pathname)
  532. char   *sysname, *pathname;
  533. {
  534.     char    name[NAMESIZ],*p,t;
  535.  
  536. #ifdef DBM
  537.     datum lhs,rhs;
  538. #endif
  539. #ifdef DEBUG
  540. if (Debug>2)
  541.     printf("In getpath: Sysname = %s, Pathfile = %s\n",sysname,paths);
  542. #endif
  543. #ifdef DBM
  544.    if (dbminit(paths) <0) return(EX_NOINPUT);
  545.         lhs.dptr = sysname;
  546.     lhs.dsize = strlen(sysname)+1;
  547.     rhs = fetch(lhs);
  548.     if (rhs.dptr == NULL) return(EX_NOHOST); /* no name found */
  549.     strcpy(pathname,rhs.dptr);
  550.         return(EX_OK);            /* system name found */
  551.  
  552. #else
  553. if (in == NULL) {
  554.     if ((in = fopen(paths, "r")) == NULL)
  555.         return(EX_NOINPUT);
  556.     }
  557.     else
  558.     rewind(in);
  559.  
  560.     for (;;)
  561.     {
  562.     p = &name[0];
  563.     while ((t = getc(in)) != EOF && (*p++ = t) != ' ' && t != '\t'); /* read the system name */
  564.     if( t == EOF) return(EX_NOHOST);
  565.     *--p = '\0';                    /* set end of string */
  566.     p = &name[0];
  567. #ifdef DEBUG
  568.     if (Debug>4) printf("Found %s\n",p);
  569. #endif
  570.     if (strcmp (p,sysname) == 0)
  571.         break;
  572.     while ((getc (in) != '\n'));            /* skip this path */
  573.     }
  574.  
  575.     p = pathname;                    /* save start loc of pathname */
  576.     while ((*pathname++ = getc (in)) != '\n');
  577.     *--pathname = '\0';
  578.     pathname = p;
  579.     return(EX_OK);            /* system name found */
  580. #endif
  581. }
  582. SHAR_EOF
  583. if test 2798 -ne "`wc -c < 'getpath.c'`"
  584. then
  585.     echo shar: error transmitting "'getpath.c'" '(should have been 2798 characters)'
  586. fi
  587. fi # end of overwriting check
  588. echo shar: extracting "'makefile'" '(2613 characters)'
  589. if test -f 'makefile'
  590. then
  591.     echo shar: will not over-write existing file "'makefile'"
  592. else
  593. sed 's/^X//' << \SHAR_EOF > 'makefile'
  594. ####################################################################
  595. # makefile for uumail & uupath
  596. # program to integrate with pathalias created uucpmap databases
  597. # programs originally developed by Jeff Donnelly
  598. # updated to use pathalias database by Stan Barber
  599. # $Header: makefile,v 1.3 85/08/03 00:38:33 UUCP Exp $
  600. #
  601. # the following defines should be configured for you site
  602. # add -DDBM to CCFLAGS if your pathalias database used the
  603. # dbm(3) routines
  604. # if you are a ATT system III or system V site
  605. # or a masscomp add the -DSYSIII flags
  606. # If you want to use the opath subroutine to deal with
  607. # domain names add the -DOPATH flag to the CFLAGS line
  608. # you may want to modify the LIBS line to correspond to 
  609. # libraries that you may need at you site
  610. # see conf.h for other changes that may need be made
  611. # IMPORTANT INFORMATION ABOUT UUCP
  612. # If your uucp does not understand the -g (grade) flag
  613. # add the -DNOGRADE flag to CFLAGS.
  614. # If your uucp does not know about the -a (returnto) flag
  615. # add the -DNORETURN flag to CFLAGS
  616. # $Log:    makefile,v $
  617. # Revision 1.3  85/08/03  00:38:33  UUCP
  618. # Added support for shar and RCS.
  619. # Changed name of gethostname to gethostnam to allow RCS to work right.
  620. # Stan Barber
  621. # 
  622. # Revision 1.2  85/07/11  19:28:52  sob
  623. # updated with gethostname.c
  624. # 
  625. # Revision 1.1  85/07/11  19:23:22  sob
  626. # Initial revision
  627. # 
  628. ###############################################################
  629. X.SUFFIXES: .c,v .h,v
  630.  
  631. CFLAGS= -O -DSYSIII -DDEBUG -DOPATH -DUGLYUUCP -DLOG
  632.  
  633. LIBS=
  634.  
  635. X.c,v.c:
  636.     co -q $*.c
  637.  
  638. X.h,v.h:
  639.     co -q $*.h
  640.  
  641. all: uumail rmail
  642.  
  643. uumail: getpath.o uumail.o gethostnam.o opath.o
  644.     cc $(CFLAGS) getpath.o uumail.o gethostnam.o opath.o -o uumail $(LIBS)
  645.  
  646. address:address.o opath.o getpath.o
  647.     cc $(CFLAGS) address.o opath.o getpath.o -o address $(LIBS)
  648.  
  649. getpath.o: getpath.c uuconf.h
  650.  
  651. uupath.o: uupath.c uuconf.h
  652.  
  653. uumail.o: uumail.c uuconf.h
  654.  
  655. gethostnam.o:gethostnam.c
  656.  
  657. address.o:address.c
  658.  
  659. opath.o:opath.c
  660.  
  661. rmail: rmail.c gethostnam.o
  662.     cc $(CFLAGS) rmail.c gethostnam.o -o rmail $(LIBS)
  663.  
  664. lint:
  665.     lint $(CFLAGS) getpath.c uumail.c gethostnam.c opath.c
  666.  
  667. clean: 
  668.     rm -f *.o *.CKP *.BAK *.bak
  669.  
  670. doc: uumail.1 uupath.1 address.1 opath.3
  671.     nroff -man uumail.1 >uumail.cat; nroff -man uupath.1 >uupath.cat; nroff -man address.1 >address.cat; nroff -man opath.3 >opath.cat
  672.  
  673. shar: domains palias rmail.c opath.c address.c uumail.c uuconf.h gethostnam.c uupath.c getpath.c README makefile uumail.1 uupath.1 README.orig opath.3 address.1
  674.     shar domains palias rmail.c opath.c address.c uumail.c uuconf.h gethostnam.c uupath.c getpath.c README makefile uumail.1 uupath.1 README.orig opath.3 address.1> shar.out
  675.  
  676. SHAR_EOF
  677. if test 2613 -ne "`wc -c < 'makefile'`"
  678. then
  679.     echo shar: error transmitting "'makefile'" '(should have been 2613 characters)'
  680. fi
  681. fi # end of overwriting check
  682. echo shar: extracting "'opath.3'" '(4896 characters)'
  683. if test -f 'opath.3'
  684. then
  685.     echo shar: will not over-write existing file "'opath.3'"
  686. else
  687. sed 's/^X//' << \SHAR_EOF > 'opath.3'
  688. X.TH OPATH 3 "PE SDC"
  689. X.SH NAME
  690. opath - Generate a UUCP route from an RFC822 address
  691. X.br
  692. oupath - Generate a UUCP route from a (possibly disconnected) UUCP path
  693. X.SH SYNOPSIS
  694. char *opath(s)
  695. X.br
  696. char *s;
  697. X.sp 1
  698. char *oupath(s)
  699. X.br
  700. char *s;
  701. X.SH DESCRIPTION
  702. These routines use the \fBpathalias\fR database to generate UUCP routing
  703. paths from your local site to specified remote sites on either the UUCP
  704. network or other connected networks.
  705. X.PP
  706. \fBopath\fR takes one argument, an RFC822 address, as described in
  707. ADDRESS(1).  From this, it generates and returns a UUCP path to the site
  708. named in the argument.
  709. X.PP
  710. \fBoupath\fR takes one argument, a UUCP path.  If the next site on this
  711. path is named \fIx\fR, \fBoupath\fR will prepend a path from your site to
  712. \fIx\fR, if \fIx\fR is nonadjacent to your site.  If \fIx\fR is a domain,
  713. i.e. contains a dot (.), \fBoupath\fR will generate a path to a gateway
  714. for this domain.  Note that \fBoupath\fR will \fInot\fR alter the argument
  715. path, other than to make the above transformations; it does not check whether
  716. sites in the argument are adjacent to one another, or whether they represent
  717. an optimal path; it is assumed that if the user has specified a path, then
  718. he wants to use that path.
  719. X.PP
  720. The principal difference between \fBopath\fR and \fBoupath\fR is that the
  721. former gives precedence to ``@'', whereas the latter gives precedence
  722. to ``!''.  The former is intended to be invoked when receiving mail from
  723. a user interface or a non-UUCP source (if the subsequent transport mechanism
  724. is to be UUCP), whereas the latter is intended solely to be used by UUCP
  725. internal software, principally \fBrmail\fR, in routing mail through the
  726. UUCP network.
  727. X.SH "FILES"
  728. \fI/usr/lib/uucp/archive\fR - The pathalias database, in DBM(3) format.
  729. XSee PATHALIAS(1) for information; pathalias is a public-domain program
  730. distributed via the Usenet's net.sources facility.
  731. X.br
  732. X.sp 1
  733. \fI/usr/lib/uucp/domains\fR - The domain/gateway table.  Each line of this
  734. file consists of either a ``#'' followed by arbitrary comment text, or
  735. an entry of the form:
  736. X.br
  737. X.in 1i
  738. <domain>,<path>,<reserved>,<template>
  739. X.br
  740. X.in
  741. Where <domain> is the string (in capital letters) identifying a particular
  742. <path> is a string which may be included at an arbitrary point in the
  743. generated route, <reserved> is currently unused, and <template> is a string
  744. indicating the format of the generated route.
  745. X.PP
  746. The <template> is a printf-style string; it is \fBnot\fR quoted, and
  747. begins at the character immediately following the comma which separates
  748. <template> from <reserved>.  The <template> may consist of arbitrary ASCII
  749. characters, which are copied unchanged into the generated route; or of
  750. a percent (%) sign followed by one of the following characters:
  751. X.IP P
  752. The <path> string is inserted.  The <path> may consist either of a string
  753. which is inserted unchanged; or of the character ``>'' followed by the
  754. name of a UUCP site, in which case the entire <path> string is replaced
  755. with a string representing the path to the named site.  The last token on
  756. this string is the site named in the original <path> string, without a
  757. following ``!''.
  758. X.IP U
  759. The user name from the original address is inserted.
  760. X.IP N
  761. The site name from the original address, with the domain specifiers
  762. removed, is inserted.
  763. X.IP D
  764. The site name from the original address, including the domain specifiers,
  765. is inserted.
  766. X.IP R
  767. The UUCP path to the site named in the original address is looked up in
  768. the pathalias database and inserted.  Note that this path is looked up
  769. only when the %R is seen while scanning the <template>, so an error message
  770. for an invalid site name is generated if and only if it appears in an
  771. address with a domain which contains a %R in its template.
  772. X.PP
  773. When making entries in the domain table, domain names which are a suffix of
  774. another domain name in the table should be ordered such that the longer
  775. string(s) appear first.  For example, .WA.UUCP should preceed .UUCP in
  776. the table.  A linear search is made of the table, and the first domain
  777. found in the table which is a suffix of the domain in the designated address
  778. is used as the domain in generating the routing.
  779. X.PP
  780. XFollowing are some example entries for the domain table.  Note that all
  781. domain names begin with a ``.''.
  782. X.sp 1
  783. X.nf
  784. X.in 1i
  785. # This is a comment
  786. \&.HP.UUCP,,,%R!%U
  787. \&.UUCP,,,%R!%U
  788. \&.CSNET,>decwrl,,%P!%U%%%S@CSNET-RELAY.ARPA
  789. \&.EDU,>ucbvax,,%P!%D
  790. X.in
  791. X.fi
  792. X.sp 1
  793. X.SH "SEE ALSO"
  794. PATHALIAS(1), ADDRESS(1), RMAIL(1)
  795. X.SH "AUTHOR"
  796. Eric Roskos, Perkin-Elmer Corp. SDC.
  797. X.SH "NOTE"
  798. The <reserved> field in the domain table currently has a function which
  799. may be determined by examining the source code for opath.  However, this
  800. function is a vestigal function provided for sites that used an earlier
  801. version of opath; future opath versions will use this field for a different
  802. purpose, and new users of opath therefore should \fBnot\fR use this field.
  803. SHAR_EOF
  804. if test 4896 -ne "`wc -c < 'opath.3'`"
  805. then
  806.     echo shar: error transmitting "'opath.3'" '(should have been 4896 characters)'
  807. fi
  808. fi # end of overwriting check
  809. echo shar: extracting "'opath.c'" '(5753 characters)'
  810. if test -f 'opath.c'
  811. then
  812.     echo shar: will not over-write existing file "'opath.c'"
  813. else
  814. sed 's/^X//' << \SHAR_EOF > 'opath.c'
  815. /*
  816.  * opath.c - get an optimal uucp path from the path database, using an
  817.  * RFC882-style address as input.  The '%' character is properly translated,
  818.  * and gateway-substitution is done to get mail onto other networks.
  819.  *
  820.  *
  821.  * Eric Roskos, Perkin-Elmer Corp. SDC
  822.  * Version 3.2 created 85/09/12 15:21:51
  823.  * $Log:    opath.c,v $
  824.  * Revision 3.7  85/11/14  20:22:16  sob
  825.  * Added #ifdef DEBUG to allow compiliation without DEBUG
  826.  * 
  827.  * Revision 3.6  85/11/08  03:05:22  sob
  828.  * release version
  829.  * 
  830.  * Revision 3.5  85/10/09  03:20:07  sob
  831.  * Added strindex call to make striping the printf stuff more pleasing.
  832.  * 
  833.  * Revision 3.4  85/09/30  02:49:12  sob
  834.  * Updated to use getpath revised by Stan Barber
  835.  * 
  836.  * Revision 3.3  85/09/16  18:32:26  sob
  837.  * This version will use the getpath subroutine used by uupath/uumail
  838.  * and is not dependant on whether it is DBM or not.
  839.  * Also uses the uuconf include file.
  840.  * 
  841.  * Revision 3.2  85/09/16  17:50:07  sob
  842.  * Added to RCS
  843.  * 
  844.  */
  845.  
  846. static char *opathsccsid = "@(#)opath.c    3.2 (peora) 15:21:51 - 85/09/12";
  847. static char opathrcsid[] = "$Header: opath.c,v 3.7 85/11/14 20:22:16 sob Exp $";
  848. #ifdef OPATH
  849. #include "uuconf.h"
  850.  
  851. /**
  852.  ** User-configurable parameters
  853.  **/
  854.  
  855. /**
  856.  ** Global Variables
  857.  **/
  858.  
  859. static char pval[150]; /* the path string is built here */
  860.  
  861. /*
  862.  * the following are used to pass results by side-effect from the domain()
  863.  * routine.
  864.  */
  865.  
  866. static char prefix[80], suffix[80], fullsite[80];
  867.  
  868. /**
  869.  ** Subroutines
  870.  **/
  871.  
  872. /*
  873.  * The Domain Table and its associated routines
  874.  */
  875.  
  876. static struct domains
  877. {
  878.     char dom[50];
  879.     char pre[50];
  880.     char suf[50];
  881.     char map[50];
  882. } domtab[100];
  883.  
  884. /* Inline routine to copy a domain into the domain table */
  885.  
  886. #define DOMCPY(fld) { int i = 0; q=dp->fld; while (*p!=','&&*p!='\n'&&*p) \
  887.             {*q++ = *p++; if (i++>=48) break;} \
  888.             *q++ = '\0'; if (!*p) { \
  889.             fprintf(stderr,"opath: fld(s) missing in %s at %s\n", \
  890.             s, buf); \
  891.             dp++; continue;} p++; }
  892.  
  893. /* Load the domain table from disk */
  894.  
  895. static int
  896. loaddomtab(s)
  897. char *s;
  898. {
  899. XFILE *f;
  900. char buf[100];
  901. register char *p,*q;
  902. struct domains *dp;
  903.  
  904.     f = fopen(s,"r");
  905.     if (f==NULL)
  906.     {
  907.         fprintf(stderr,"opath: can't open domain file '%s'\n",s);
  908.         exit(1);
  909.     }
  910.  
  911.     dp = domtab;
  912.  
  913.     while (fgets(buf,100,f))
  914.     {
  915.         if (buf[0]=='#') continue; /* comments start with "#" */
  916.         p = buf;
  917.         DOMCPY(dom);
  918.         DOMCPY(pre);
  919.         DOMCPY(suf);
  920.         DOMCPY(map);
  921.         if (dp->map[0] == '\0')
  922.         {
  923.             fprintf(stderr,"opath: bad route template in %s\n",s);
  924.             strcpy(dp->map,"Invalid");
  925.         }
  926.         dp++;
  927.     }
  928.  
  929.     dp->map[0] = '\0';  /* mark end of table */
  930.     fclose(f);
  931.  
  932.     return(0);
  933. }
  934.  
  935. /* Get a UUCP path from the pathalias database 
  936.  * and compensate for the format.
  937.  * Typically the format is
  938.  * site1!site2!site3!%s to be used in *printf statements.
  939.  * We don't want the !%s, so we cut it off.
  940.  * Pretty gross, but it works.
  941.  */
  942.  
  943. static char *
  944. gpath(s)
  945. char *s;
  946. {
  947. static char path[100];
  948. int getpath(),x;
  949.     getpath(s,&path[0],paths);
  950.         x=strindex(&path[0],"!%s");
  951.     if (x >0) path[x] = '\0';
  952. #ifdef DEBUG
  953.     if (Debug>1)fprintf(stderr,"Getpath returns: %s\n",&path[0]);
  954. #endif
  955.     return(&path[0]);
  956. }
  957.  
  958. /* returns location of tx in sx */
  959. strindex(sx,tx)
  960. char * sx, *tx;
  961. {
  962.     int i,n;
  963.     n = strlen(tx);
  964.     for (i=0;sx[i] != '\0'; i++)
  965.         if (strncmp(sx+i,tx,n) ==0)
  966.             return(i);
  967.     return (-1);
  968. }
  969.  
  970. /* String compare: entire first argument must match suffix of 2nd argument */
  971.  
  972. static int
  973. domcmp(ss,tt)
  974. char *ss, *tt;
  975. {
  976. char *s, *t;
  977. int cmp;
  978.  
  979.     s = ss + strlen(ss) - 1;
  980.     t = tt + strlen(tt) - 1;
  981.  
  982.     do
  983.     {
  984.         if (*s - *t) break;
  985.         s--;
  986.         t--;
  987.     } while (s >= ss);
  988.  
  989.     if (++s == ss) return(0);
  990.     else return(1);
  991. }
  992.  
  993. /* Look up a domain, and by side effect set prefix and suffix appropriately */
  994.  
  995. char *domain(s)
  996. char *s;
  997. {
  998. struct domains *d;
  999. char *p;
  1000. static int loaded = 0;
  1001.  
  1002.     if (!loaded++) loaddomtab(ConfFile);
  1003.  
  1004.     if (*s!='.') /* default to UUCP domain */
  1005.     {
  1006.         prefix[0]=suffix[0]='\0';
  1007.         return("%R!%U");
  1008.     }
  1009.  
  1010.     for (p=s; *p; p++) if (*p>='a' && *p<='z') *p -= 'a'-'A';
  1011.  
  1012.     for (d = &domtab[0]; (int)d->map[0]; d++)
  1013.     {
  1014.         if (domcmp(d->dom,s)==0) break;
  1015.     }
  1016.  
  1017.     strcpy(prefix,(d->pre[0]=='>')? gpath(&d->pre[1]) : d->pre);
  1018.     strcpy(suffix,d->suf);
  1019.  
  1020.     return(d->map);
  1021. }
  1022.  
  1023. /* opath: generates a UUCP path from an RFC-822 address */
  1024.  
  1025. #define COPYON(s) {char *r; r=s; while (*r) *p++ = *r++; *p = '\0';}
  1026.  
  1027. char *
  1028. opath(s)
  1029. char *s;
  1030. {
  1031. char user[50],site[50];
  1032. static char cm[150];
  1033. XFILE *f;
  1034. char *p, *q, *t;
  1035. char *d;
  1036. int i;
  1037. int found;
  1038. char *suf;
  1039.  
  1040.     for (p=user,q=s;(*p = *q)!='@'; p++,q++)
  1041.         if (*q=='\0') return(s);
  1042.     *p = '\0';
  1043.  
  1044.     strcpy(fullsite,++q);
  1045.  
  1046.     for (p=site;(*p = *q)!='.'; p++,q++)
  1047.         if (*q=='\0') break;
  1048.     *p = '\0';
  1049.  
  1050.     d = domain(q);
  1051.  
  1052.     if (d[0]=='\0') return(s); /* unknown domain - do nothing */
  1053.  
  1054.     for (p=pval, q=d; *q; q++)
  1055.     {
  1056.         if (*q=='%')
  1057.         {
  1058.             switch(*++q)
  1059.             {
  1060.             case 'P':
  1061.                 COPYON(prefix);
  1062.                 break;
  1063.  
  1064.             case 'S':
  1065.                 COPYON(suffix);
  1066.                 break;
  1067.  
  1068.             case 'U':
  1069.                 COPYON(user);
  1070.                 break;
  1071.  
  1072.             case 'N':
  1073.                 COPYON(site);
  1074.                 break;
  1075.  
  1076.             case 'D':
  1077.                 COPYON(fullsite);
  1078.                 break;
  1079.  
  1080.             case 'R':
  1081.                 COPYON(gpath(site));
  1082.                 break;
  1083.  
  1084.             case '%':
  1085.                 *p++ = '%';
  1086.                 break;
  1087.             }
  1088.         }
  1089.         else
  1090.             *p++ = *q;
  1091.     }
  1092.  
  1093.     return(pval);
  1094. }
  1095.  
  1096. /* oupath: generates a uucp path from a (possibly disconnected) uucp path */
  1097.  
  1098. char *oupath(s)
  1099. char *s;
  1100. {
  1101. char *p,*q;
  1102. static char adr[100];
  1103. char first[100];
  1104. int found;
  1105.  
  1106.     for (p=s,q=first,found=0; *p!='!' && *p!='\0'; p++)
  1107.     {
  1108.         if (*p=='.') found++;
  1109.         *q++ = *p;
  1110.     }
  1111.     if (*p=='\0') return (s);
  1112.  
  1113.     *q = '\0';
  1114.  
  1115.     if (found)
  1116.     {
  1117.         strcpy(adr,++p);
  1118.         strcat(adr,"@");
  1119.         strcat(adr,first);
  1120.         return(opath(adr));
  1121.     }
  1122.     else
  1123.     {
  1124.     int i;
  1125.         strcpy(adr,gpath(first));
  1126.         strcat(adr,/* ++ */p);
  1127.  
  1128.         return(adr);
  1129.     }
  1130. }
  1131.  
  1132.  
  1133. opathlog(fmt,a,b,c,d)
  1134. char *fmt;
  1135. int a,b,c,d;
  1136. {
  1137. XFILE *f;
  1138.  
  1139.     f = fopen(logfile,"a");
  1140.     if (f==NULL) return;
  1141.  
  1142.     fprintf(f,fmt,a,b,c,d);
  1143.     fclose(f);
  1144. }
  1145. #endif
  1146. SHAR_EOF
  1147. if test 5753 -ne "`wc -c < 'opath.c'`"
  1148. then
  1149.     echo shar: error transmitting "'opath.c'" '(should have been 5753 characters)'
  1150. fi
  1151. fi # end of overwriting check
  1152. echo shar: extracting "'palias'" '(151 characters)'
  1153. if test -f 'palias'
  1154. then
  1155.     echo shar: will not over-write existing file "'palias'"
  1156. else
  1157. sed 's/^X//' << \SHAR_EOF > 'palias'
  1158. neuro1 %s
  1159. rice  rice!%s
  1160. baylor baylor!%s
  1161. kitty baylor!kitty!%s
  1162. shell shell!%s
  1163. decwrl shell!ihnp4!decwrl!%s
  1164. ihnp4 shell!ihnp4!%s
  1165. psuvax shell!psuvax!%s
  1166. SHAR_EOF
  1167. if test 151 -ne "`wc -c < 'palias'`"
  1168. then
  1169.     echo shar: error transmitting "'palias'" '(should have been 151 characters)'
  1170. fi
  1171. fi # end of overwriting check
  1172. echo shar: extracting "'rmail.c'" '(2622 characters)'
  1173. if test -f 'rmail.c'
  1174. then
  1175.     echo shar: will not over-write existing file "'rmail.c'"
  1176. else
  1177. sed 's/^X//' << \SHAR_EOF > 'rmail.c'
  1178. #ifndef lint
  1179. static char rcsid[]="$Header: rmail.c,v 1.3 85/11/08 03:05:31 sob RELEASE $";
  1180.  
  1181. #endif
  1182.  
  1183. /*
  1184. **  RMAIL -- UUCP mail server.
  1185. **
  1186. **    This program reads the >From ... remote from ... lines that
  1187. **    UUCP is so fond of and turns them into something reasonable.
  1188. **    It calls uumail giving it a -f option built from these
  1189. **    lines.
  1190. */
  1191.  
  1192. #define _DEFINE
  1193.  
  1194. #include "uuconf.h"
  1195. extern FILE *popen();
  1196. extern char *index();
  1197. extern char *rindex();
  1198.  
  1199. # define MAILER    "/usr/lib/uucp/uumail"
  1200.  
  1201. main(argc, argv)
  1202.     char **argv;
  1203. {
  1204.     FILE *out;    /* output to mail handler */
  1205.     char lbuf[512];    /* one line of the message */
  1206.     char from[512];    /* accumulated path of sender */
  1207.     char ufrom[64];    /* user on remote system */
  1208.     char sys[64];    /* a system in path */
  1209.     char junk[512];    /* scratchpad */
  1210.     char cmd[2000];
  1211.     register char *cp;
  1212.     register char *uf;    /* ptr into ufrom */
  1213.     int i;
  1214.  
  1215. # ifdef DEBUG
  1216.     if (argc > 1 && strcmp(argv[1], "-T") == 0)
  1217.     {
  1218.         Debug = TRUE;
  1219.         argc--;
  1220.         argv++;
  1221.     }
  1222. # endif DEBUG
  1223.  
  1224.     if (argc < 2)
  1225.     {
  1226.         fprintf(stderr, "Usage: rmail user ...\n");
  1227.         exit(EX_USAGE);
  1228.     }
  1229.  
  1230.     (void) strcpy(from, "");
  1231.     (void) strcpy(ufrom, "/dev/null");
  1232.  
  1233.     for (;;)
  1234.     {
  1235.         (void) fgets(lbuf, sizeof lbuf, stdin);
  1236.         if (strncmp(lbuf, "From ", 5) != 0 && strncmp(lbuf, ">From ", 6) != 0)
  1237.             break;
  1238.         (void) sscanf(lbuf, "%s %s", junk, ufrom);
  1239.         cp = lbuf;
  1240.         uf = ufrom;
  1241.         for (;;)
  1242.         {
  1243.             cp = index(cp+1, 'r');
  1244.             if (cp == NULL)
  1245.             {
  1246.                 register char *p = rindex(uf, '!');
  1247.  
  1248.                 if (p != NULL)
  1249.                 {
  1250.                     *p = '\0';
  1251.                     if (uf != NULL) 
  1252.                         (void) strcpy(sys, uf);
  1253.                     else
  1254.                         gethostname(sys,32);
  1255.                     uf = p + 1;
  1256.                     break;
  1257.                 }
  1258.                 cp = "remote from somewhere";
  1259.             }
  1260. #ifdef DEBUG
  1261.             if (Debug)
  1262.                 printf("cp='%s'\n", cp);
  1263. #endif
  1264.             if (strncmp(cp, "remote from ", 12)==0)
  1265.                 break;
  1266.         }
  1267.         if (cp != NULL)
  1268.             (void) sscanf(cp, "remote from %s", sys);
  1269.         (void) strcat(from, sys);
  1270.         (void) strcat(from, "!");
  1271. #ifdef DEBUG
  1272.         if (Debug)
  1273.             printf("ufrom='%s', sys='%s', from now '%s'\n", uf, sys, from);
  1274. #endif
  1275.     }
  1276.     (void) strcat(from, uf);
  1277.  
  1278. /*    (void) sprintf(cmd, "exec %s -em -f%s", MAILER, from);*/
  1279.     (void) sprintf(cmd, "exec %s -f%s", MAILER,from);
  1280.     while (*++argv != NULL)
  1281.     {
  1282.         (void) strcat(cmd, " '");
  1283.         if (**argv == '(')
  1284.             (void) strncat(cmd, *argv + 1, strlen(*argv) - 2);
  1285.         else
  1286.             (void) strcat(cmd, *argv);
  1287.         (void) strcat(cmd, "'");
  1288.     }
  1289. #ifdef DEBUG
  1290.     if (Debug)
  1291.         printf("cmd='%s'\n", cmd);
  1292. #endif
  1293.     out = popen(cmd, "w");
  1294.     fputs(lbuf, out);
  1295.     while (fgets(lbuf, sizeof lbuf, stdin))
  1296.         fputs(lbuf, out);
  1297.     i = pclose(out);
  1298.     if ((i & 0377) != 0)
  1299.     {
  1300.         fprintf(stderr, "pclose: status 0%o\n", i);
  1301.         exit(EX_OSERR);
  1302.     }
  1303.  
  1304.     exit((i >> 8) & 0377);
  1305. }
  1306. SHAR_EOF
  1307. if test 2622 -ne "`wc -c < 'rmail.c'`"
  1308. then
  1309.     echo shar: error transmitting "'rmail.c'" '(should have been 2622 characters)'
  1310. fi
  1311. fi # end of overwriting check
  1312. echo shar: extracting "'uuconf.h'" '(2942 characters)'
  1313. if test -f 'uuconf.h'
  1314. then
  1315.     echo shar: will not over-write existing file "'uuconf.h'"
  1316. else
  1317. sed 's/^X//' << \SHAR_EOF > 'uuconf.h'
  1318. /* $Header: uuconf.h,v 1.4 85/10/02 02:16:21 sob Exp $
  1319.  * Configuration for uumail and uupath utilities
  1320.  * Please see the header for makefile for changes you may
  1321.  * need to make there.
  1322.  * $Log:    uuconf.h,v $
  1323.  * Revision 1.4  85/10/02  02:16:21  sob
  1324.  * Added LOCALMAIL definition
  1325.  * 
  1326.  * Revision 1.3  85/09/30  02:50:51  sob
  1327.  * Added pwd.h to list of include files
  1328.  * 
  1329.  * Revision 1.2  85/07/11  19:29:34  sob
  1330.  * *** empty log message ***
  1331.  * 
  1332.  * Revision 1.1  85/07/11  19:22:20  sob
  1333.  * Initial revision
  1334.  * 
  1335.  */
  1336. #include <stdio.h>
  1337. #include <ctype.h>
  1338. #include <pwd.h>
  1339. #include <signal.h>
  1340. #include <setjmp.h>
  1341.  
  1342. /*
  1343.  * sysexits is a file of exit codes that are used in sendmail
  1344.  * and other programs ...
  1345.  */
  1346. #include <sysexits.h>
  1347. /* if you don't have sysexits.h here are the useful parts */
  1348. #ifndef EX_BASE
  1349.  
  1350. # define EX_OK        0    /* successful termination */
  1351.  
  1352.  
  1353. # define EX_USAGE    64    /* command line usage error */
  1354. # define EX_DATAERR    65    /* data format error */
  1355. # define EX_NOINPUT    66    /* cannot open input */
  1356. # define EX_NOHOST    68    /* host name unknown */
  1357. # define EX_UNAVAILABLE    69    /* service unavailable */
  1358. # define EX_SOFTWARE    70    /* internal software error */
  1359. # define EX_OSERR    71    /* system error (e.g., can't fork) */
  1360. # define EX_OSFILE    72    /* critical OS file missing */
  1361. # define EX_CANTCREAT    73    /* can't create (user) output file */
  1362. # define EX_IOERR    74    /* input/output error */
  1363. #endif
  1364.  
  1365. typedef char bool;
  1366.  
  1367. #ifdef DBM
  1368. #include <dbm.h>
  1369. #endif
  1370.  
  1371. #ifdef SYSIII
  1372. #define index strchr
  1373. #define rindex strrchr
  1374. #include <sys/utsname.h>
  1375. #endif
  1376.  
  1377. #define NAMESIZ 32 /* system name size */
  1378. #define PATHSIZ 16*NAMESIZ /* path length */
  1379.  
  1380. #define TRUE    1
  1381. #define FALSE    0
  1382.  
  1383. /* Here's where you should put in the the name of the file
  1384.  * in which the uucpmap data is kept.
  1385.  * For those using DBM, this will be the root filename for the database
  1386.  * (eg... file.pag and file.dir with root name file)
  1387.  */
  1388.  
  1389. #define DATABASE "/usr/lib/uucp/palias"
  1390. #define CONFIGFILE "/usr/lib/uucp/domains"
  1391. #define LOGFILE "/usr/adm/uumail.log"
  1392. /* this needs to be a printf-like string to deliver LOCAL mail */
  1393. /* usually this is either /bin/mail or /bin/binmail */
  1394.  
  1395. #define LOCALMAIL "/bin/bellmail %s"
  1396.  
  1397. #ifdef _DEFINE
  1398. #define EXTERN 
  1399. #else
  1400. #define EXTERN extern
  1401. #endif
  1402.  
  1403. EXTERN int Debug;
  1404. EXTERN char *paths;
  1405. EXTERN char *ConfFile;
  1406. EXTERN char Myname[NAMESIZ];
  1407. EXTERN char *logfile;
  1408. EXTERN char    OpMode;        /* operation mode, see below */
  1409. /* These don't do anything yet.... next time they will do something */
  1410. #define MD_DELIVER    'm'        /* be a mail sender */
  1411. #define MD_ARPAFTP    'a'        /* old-style arpanet protocols */
  1412. #define MD_SMTP        's'        /* run SMTP on standard input */
  1413. #define MD_DAEMON    'd'        /* run as a daemon */
  1414. #define MD_VERIFY    'v'        /* verify: don't collect or deliver */
  1415. #define MD_TEST        't'        /* test mode: resolve addrs only */
  1416. #define MD_INITALIAS    'i'        /* initialize alias database */
  1417. #define MD_PRINT    'p'        /* print the queue */
  1418. #define MD_FREEZE    'z'        /* freeze the configuration file */
  1419. SHAR_EOF
  1420. if test 2942 -ne "`wc -c < 'uuconf.h'`"
  1421. then
  1422.     echo shar: error transmitting "'uuconf.h'" '(should have been 2942 characters)'
  1423. fi
  1424. fi # end of overwriting check
  1425. echo shar: extracting "'uumail.1'" '(2272 characters)'
  1426. if test -f 'uumail.1'
  1427. then
  1428.     echo shar: will not over-write existing file "'uumail.1'"
  1429. else
  1430. sed 's/^X//' << \SHAR_EOF > 'uumail.1'
  1431. X.TH "UUMAIL" "8" "Baylor College of Medicine"
  1432. X.fi
  1433. X.ad b
  1434. X.SH NAME
  1435. uumail \- rewrite address & route mail using uucpmap database 
  1436. X.br
  1437. uupath \- print the uucp path to a host
  1438. X.SH SYNOPSIS
  1439. X.B uumail [ \fIoptions\fR ] \fIaddress\fR
  1440. X.br
  1441. X.B uupath \fIhostname\fR
  1442. X.SH DESCRIPTION
  1443. X.B Uumail
  1444. is designed to be used as a mail delivery program to correctly
  1445. route mail over uucp connections.
  1446. X.SS Standard Options
  1447. X.IP "-f\fIaddress\fR" 16
  1448. The -f option sets the address of the sender of the mail. If this flag 
  1449. is not used, the sender will be established by usings environmental variables
  1450. (like 
  1451. X.B LOGNAME
  1452. and
  1453. X.B USER
  1454. ) or using getlogin(3).
  1455. X.IP "-m" 16
  1456. The -m option causes the mail to also be sent to the sender of the message.
  1457. X.IP "-c" 16
  1458. The -c option causes
  1459. X.B uucico 
  1460. to be started immediately after queuing the mail.
  1461. The default just queues the mail.
  1462. X.IP "-h" 16
  1463. The -h option causes no From_ line to be added to the beginning of file.
  1464. This is useful when uumail is being used as a mailer for sendmail(8).
  1465. X.SS Compile-time Configurable Options
  1466. X.IP "-d[1-6]" 16
  1467. The -d option turns on the limited debugging facility built into the
  1468. mailer.  In debug mode, the mailer does not actually mail anything, but
  1469. tells you what it would do if it did do it. The level of debugging can
  1470. be set by following the 
  1471. X.I -d
  1472. flag with a number between 1 and 6.
  1473. X.IP "-g[A-Z]" 16
  1474. If your 
  1475. X.B uux(1)
  1476. supports grading of transactions, the -g option can be used to set the
  1477. grade of this mail. A grade of \fIC\fR is used by default.
  1478.  
  1479. X.SS Arguments
  1480. X.IP \fIhost!user\fR 16
  1481. where host is a system node name on the network and user is the login
  1482. name of the addressee.
  1483. X.IP \fIuser@host.domain\fR
  1484. same as above with the addition of a domain specifier like
  1485. X.B .ARPA, .GOV, .COM, .EDU
  1486. etc.
  1487. X.SH FILES
  1488. X.IP "/usr/lib/uucp/palias" 20
  1489. Path file produced by pathalias.
  1490. X.IP "/usr/lib/uucp/uucp/domains" 20
  1491. Domain rewriting rules for opath(3).
  1492. X.IP "/usr/adm/uumail.log" 20
  1493. Log of uumail activity.
  1494. X.SH "SEE ALSO"
  1495. pathalias(1), Pnews(1), Rnmail(1), rn(1), postnews(1), readnews(1),
  1496. opath(3), sendmail(8)
  1497.  
  1498. X.SH AUTHORS
  1499. X.br
  1500. XStan Barber, Baylor College of Medicine
  1501. X.br
  1502. Getpath routine by John Donnelly, University of Illinois
  1503. X.br
  1504. Gethostname routine by Peter Honeyman, Princeton
  1505. X.br
  1506. Opath routine by Eric Roskos, Perkin-Elmer
  1507.  
  1508. SHAR_EOF
  1509. if test 2272 -ne "`wc -c < 'uumail.1'`"
  1510. then
  1511.     echo shar: error transmitting "'uumail.1'" '(should have been 2272 characters)'
  1512. fi
  1513. fi # end of overwriting check
  1514. echo shar: extracting "'uumail.c'" '(11965 characters)'
  1515. if test -f 'uumail.c'
  1516. then
  1517.     echo shar: will not over-write existing file "'uumail.c'"
  1518. else
  1519. sed 's/^X//' << \SHAR_EOF > 'uumail.c'
  1520. /*
  1521.  *  U U M A I L
  1522.  *  This program when invoked in the form:
  1523.  *  uumail host!user will consult the local usemap for
  1524.  *  the proper routing.
  1525.  * 
  1526.  *  If it finds it, it will invoke the proper uux call
  1527.  *  to send the mail.
  1528.  *  Otherwise it aborts with an error 68 (host unknown)
  1529.  * $Log:    uumail.c,v $
  1530.  * Revision 2.7  85/11/18  12:36:48  sob
  1531.  * Added the -h option to cause uumail NOT to add a From_ line.
  1532.  * 
  1533.  * Revision 2.6  85/11/14  20:20:06  sob
  1534.  * Added #ifdef DEBUG to allow compiliation with out DEBUG installed
  1535.  * 
  1536.  * Revision 2.5  85/11/14  20:14:11  sob
  1537.  * Another little buggie in the log format...sheesh.
  1538.  * 
  1539.  * Revision 2.4  85/11/13  15:53:18  sob
  1540.  * Reformated the log file a little bit.
  1541.  * 
  1542.  * Revision 2.3  85/11/08  03:03:51  sob
  1543.  * This is the release version.
  1544.  * 
  1545.  * 
  1546.  * Revision 2.2  85/09/30  02:51:18  sob
  1547.  * This version uses opath when defined during compile time.
  1548.  * With a bit of cleaning up, this is a release version.
  1549.  * 
  1550.  * Revision 2.1  85/09/30  02:46:06  sob
  1551.  * *** empty log message ***
  1552.  * 
  1553.  * Revision 2.0  85/09/09  18:22:56  UUCP
  1554.  * *** empty log message ***
  1555.  * 
  1556.  * Revision 2.0  85/09/09  18:22:56  UUCP
  1557.  * Added flags to conform with sendmail. Also updated the flags it could send
  1558.  * to uux to conform with 4.3 uux command.
  1559.  * Will add name resolution and header checking.
  1560.  * Also will allow multiple addresses per line.
  1561.  * 
  1562.  * Revision 1.7  85/08/03  00:49:14  UUCP
  1563.  * Cleaned up with lint.
  1564.  * Stan Barber
  1565.  * 
  1566.  * Revision 1.6  85/07/11  19:30:00  sob
  1567.  * changed PATHSIZE to PATHSIZ to conform with uupath
  1568.  * 
  1569.  * Revision 1.5  85/07/11  18:08:13  sob
  1570.  * This one works both as uumail and uupath!
  1571.  * Stan
  1572.  * 
  1573.  * Revision 1.4  85/07/10  18:35:05  sob
  1574.  * moved DBM to getpath
  1575.  * Stan Barber
  1576.  * 
  1577.  * Revision 1.3  85/07/09  01:28:14  sob
  1578.  * First attempt to integrate uupath
  1579.  * Not successful. Changed PATHALIAS define
  1580.  * to DBM... will ultimately alter getpath as well
  1581.  * added gethostname call to fill in for local host.
  1582.  * 
  1583.  * Revision 1.2  85/07/08  05:29:16  sob
  1584.  * This one works with pathalias database...
  1585.  * need to modify to substitue for uupath.
  1586.  * Stan
  1587.  * 
  1588.  * Revision 1.1  85/07/08  03:11:10  sob
  1589.  * Initial revision
  1590.  * 
  1591.  */
  1592. #define _DEFINE
  1593.  
  1594. #include "uuconf.h"
  1595.  
  1596.  
  1597. EXTERN bool uupath;
  1598. extern int      errno;
  1599. extern struct passwd *getpwuid();
  1600. extern FILE    *popen();
  1601. extern char     *ctime();
  1602. extern char    *getlogin();
  1603. extern char    *index();
  1604. extern char    *rindex();
  1605. extern char    *malloc();
  1606. extern char     *getenv();
  1607. EXTERN char    progname[12];
  1608. EXTERN char  *paths;
  1609. int local;
  1610. char templet[64];
  1611. char * from;
  1612.  
  1613.  
  1614. static char Version[] ="$Header: uumail.c,v 2.7 85/11/18 12:36:48 sob Exp $";
  1615.  
  1616. main(argc, argv)
  1617.     char **argv;
  1618. {
  1619.     FILE *out, *tmpf;    /* output to uux, temp file */
  1620.     char lbuf[512]; /* for pipe to uux */
  1621.     char sender[512];    /* accumulated path of sender */
  1622.     char sys[64];    /* a system in path */
  1623.     char cmd[2000];
  1624.     char **av;
  1625.     int i,
  1626.             error = 0,
  1627.             bangcnt, hopcount = 30,
  1628.         metoo=0, noheader = 0,
  1629.         startuux ;
  1630.         
  1631.     char    c,
  1632.             grade = 'C',
  1633.        name[20],             /* The system name (if any) */
  1634.        *fname,
  1635.        *path,            /* uupath to the system */
  1636.            *sysname,            /* points to the system name */
  1637.            *p, *q,            /* tmp pointer to argv's */
  1638.        *rsys,
  1639.        *FullName;
  1640.        bool GrabTo,safecf,NoAlias;
  1641.        extern intsig();
  1642.  
  1643.     if (signal(SIGINT, SIG_IGN) != SIG_IGN)
  1644.         (void) signal(SIGINT, intsig);
  1645.     if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
  1646.         (void) signal(SIGHUP, intsig);
  1647.     (void) signal(SIGTERM, intsig);
  1648.     (void) signal(SIGPIPE, SIG_IGN);
  1649.  
  1650.  
  1651.     for (i = 3; i < 20; i++)
  1652.         (void) close(i);
  1653.     errno = 0;
  1654.     gethostname(Myname,32);
  1655.     paths=DATABASE;
  1656.     logfile=LOGFILE;
  1657.     argv[argc] = NULL;
  1658.     av = argv;
  1659.     p = rindex(*av, '/');
  1660.     if (p++ == NULL)
  1661.         p = *av;
  1662.     strcpy(progname ,p);
  1663.     if(strcmp(p,"uupath") == 0)
  1664.         uupath = TRUE;
  1665.     while ((p = *++av) != NULL && p[0] == '-')
  1666.     {
  1667.         switch (p[1])
  1668.         {
  1669.  
  1670.           case 'C':    /* select configuration file */
  1671.             ConfFile = &p[2];
  1672.             safecf = FALSE;
  1673.  
  1674.             break;
  1675.  
  1676.           case 'g':   /* set grade */
  1677.             grade = p[2];
  1678.             break;
  1679.     
  1680. # ifdef DEBUG
  1681.           case 'd':    /* debug */
  1682.             Debug= atoi(&p[2]);
  1683.             if (Debug == 0) Debug = 1;
  1684.             setbuf(stdout, (char *) NULL);
  1685.             printf("Version %s\n", Version);
  1686.             break;
  1687. # endif DEBUG
  1688.  
  1689.           case 'f':    /* from address */
  1690.           case 'r':    /* obsolete -f flag */
  1691.             p += 2;
  1692.             if (*p == '\0' && ((p = *++av) == NULL || *p == '-'))
  1693.             {
  1694.                 p = *++av;
  1695.                 if (p == NULL || *p == '-')
  1696.                 {
  1697.                     syserr("No \"from\" person");
  1698.                     av--;
  1699.                     break;
  1700.                 }
  1701.             }
  1702.             if (from != NULL)
  1703.             {
  1704.                 syserr("More than one \"from\" person");
  1705.                 break;
  1706.             }
  1707.             from = p;
  1708.             break;
  1709.  
  1710.           case 'w':    /* just print the path */
  1711.             uupath = TRUE;
  1712.             break;
  1713.           case 'm':    /* send to me too */
  1714.             metoo = TRUE;
  1715.             break;
  1716.           case 'c':    /* connect to non-local mailers */
  1717.             startuux= TRUE;
  1718.             break;
  1719.           case 'h':    /* don't add a From line */
  1720.             noheader = TRUE;
  1721.             break;
  1722.             }
  1723.     
  1724.         }
  1725.  
  1726.     if(*av==NULL && GrabTo!= TRUE)
  1727.     {
  1728.         fprintf(stderr,"Usage: %s [flags] address\n",progname);
  1729.         exit(EX_USAGE);
  1730.     }
  1731.  
  1732.     if (ConfFile == NULL) ConfFile = CONFIGFILE;
  1733.  
  1734.     if(from==NULL || strlen(from) == 0){
  1735.         if (((from = getenv("LOGNAME")) == NULL) || (strlen(from) == 0))
  1736.             from = getenv("USER");
  1737.         if ((from == NULL) || (strlen(from) == 0))
  1738.             from = getlogin();
  1739.         if ((from == NULL) || (strlen(from) == 0))
  1740.             from = getpwuid(geteuid())->pw_name;
  1741.     }
  1742.  
  1743. if (!uupath)
  1744. {    
  1745. #ifdef DEBUG
  1746.     if (Debug) printf("Mail from %s\n",from);
  1747. #endif
  1748.     /*
  1749.      * Make temporary file for letter
  1750.      * (I wish ACCESS(2) would take care of this better !!)
  1751.      */
  1752.     if ((p=getenv("HOME"))== NULL)
  1753.         p="/tmp";
  1754.     sprintf(&templet[0],"%s/.uumXXXXXX",p);
  1755.     mktemp(templet);
  1756.     unlink(templet);
  1757.     if ((i=open(templet,2)) < 0)
  1758.         {
  1759.             p="/tmp";
  1760.     
  1761.             sprintf(&templet[0],"%s/.uumXXXXXX",p);
  1762.             mktemp(templet);
  1763.             unlink(templet);
  1764.         }
  1765.     else
  1766.         {
  1767.             close(i);
  1768.             unlink(templet);
  1769.         }
  1770. #ifdef DEBUG
  1771.     if (Debug>2) printf("Temp file is %s\n",templet);
  1772. #endif
  1773.     if((tmpf = fopen(templet, "w")) == NULL){
  1774.         fprintf(stderr, "%s : can't open %s for writing\n", progname,templet);
  1775.         fclose(stdin);
  1776.         exit(EX_CANTCREAT);
  1777.  
  1778.         }
  1779.     while(fgets(lbuf,sizeof lbuf,stdin))
  1780.         fputs(lbuf,tmpf);
  1781.     fclose(tmpf);
  1782.     fclose(stdin);
  1783. /* file now saved */
  1784.     if((tmpf = fopen(templet, "r")) == NULL){
  1785.         fprintf(stderr, "%s : can't open %s for reading\n", progname,templet);
  1786.         exit(EX_OSERR);
  1787.     }
  1788.     
  1789. }    
  1790.     (void) strcpy(sender, "");
  1791.  
  1792.     path = malloc(PATHSIZ);
  1793.  
  1794.     av--;
  1795.  
  1796.     if(metoo)
  1797.     {
  1798.     *av = from;
  1799.     av --;
  1800.     }
  1801.     
  1802.     while (av++ != NULL && *av != NULL)
  1803.     {
  1804.     local = bangcnt = 0;
  1805.     
  1806.     
  1807.     q = p = *av;
  1808.     
  1809.     sysname = &name[0];
  1810.  
  1811.     
  1812.     if (uupath) 
  1813.  
  1814.     {
  1815.     (void) strcpy(sysname ,p);
  1816. #ifdef OPATH
  1817.     if ((error = getpath (&name[0], path)) != EX_OK)
  1818.         {
  1819.         if (error == EX_NOHOST) fprintf (stderr, "System %s not found in network map\n", &name[0]);
  1820.         if (error == EX_NOINPUT) fprintf(stderr,"Database %s could not be opened\n",paths);
  1821.         exit(EX_NOHOST);
  1822.         }
  1823.     }
  1824.     else 
  1825.     if (index(p,'@') == NULL) strcpy(path,oupath(p)); 
  1826.         else strcpy(path,opath(p));
  1827. #ifdef DEBUG
  1828.     if (Debug >1) fprintf(stderr,"Opath returns %s\n",path);
  1829. #endif
  1830.  
  1831.     if (path[0] == '!')  /* no match in pathalias database */
  1832.     {
  1833.         deadletter(tmpf,local);
  1834.         unlink(templet);
  1835.         exit(EX_NOHOST);
  1836.     }
  1837.    
  1838.    if (strcmp(path,p) == 0)
  1839.     {
  1840.     strcpy(path,Myname);
  1841.     local = 1;
  1842.     }
  1843.  
  1844. #else
  1845.     }
  1846.     else
  1847. {
  1848.     do                        /* count bangs */
  1849.         {
  1850.             while (((c = *p++) != '!') && (c != '\0'));
  1851.                 if (c == '!') bangcnt++;
  1852.         }
  1853.     while (c != '\0' && bangcnt == 1);
  1854.         ;
  1855.     if (bangcnt >= 1)                /* expand path */
  1856.         {
  1857.             while ((*sysname++ = *q++) != '!');
  1858.                 *--sysname = '\0';
  1859.  
  1860.             }
  1861.     /* insert code here to look at uucp neighbors & local host */
  1862.     if (bangcnt == 0) {
  1863.             strcpy(sysname,Myname);
  1864.             local = 1;
  1865.             }
  1866.     }
  1867. #ifdef DEBUG
  1868.     if (Debug>1) printf("sysname = %s\n",&name[0]);
  1869. #endif
  1870.     
  1871.     if (!local && (error = getpath (&name[0], path)) != EX_OK)
  1872.         {
  1873.         if (error == EX_NOHOST) fprintf (stderr, "System %s not found in network map\n", &name[0]);
  1874.         if (error == EX_NOINPUT) fprintf(stderr,"Database %s could not be opened\n",paths);
  1875.         exit(EX_NOHOST);
  1876.         }
  1877.  
  1878.        if (local) path = sysname;
  1879. #endif
  1880.  
  1881. #ifdef DEBUG
  1882.        if(Debug>1) printf("Path = %s\n",path);
  1883. #endif
  1884.  
  1885.     p = q;                    /* save name */
  1886.     for (i = 0; i < 1 && *p != '\0'; p++)
  1887.         if (*p == '/')
  1888.         i++;
  1889.     fname = &sender[0];
  1890.  
  1891.         if (uupath)
  1892.         sprintf(fname,path,"username");
  1893.     else
  1894.         sprintf(fname,path,q);
  1895.  
  1896.     p = &sender[0];
  1897.     rsys = &sys[0];
  1898.  
  1899.     if (!local)
  1900.         {
  1901.         while((*rsys++ = *p++) != '!');
  1902.         *--rsys = '\0';
  1903.         }
  1904.         else
  1905. /* local host, remove @ sign */
  1906.         {
  1907.         strcpy(rsys,*av);
  1908.         q=rsys;
  1909.         if (index(rsys,'@') != 0)
  1910.             { 
  1911.                 while (*q++ !='@');
  1912.                 *--q='\0';
  1913.             }
  1914.         /* assume that if it has a bang in it uux
  1915.             will either reject it or know what to do with it */
  1916.         /* this is a little gross */
  1917.         if ((q = index(rsys,'!')) != 0)
  1918.             {
  1919.             local=0;
  1920.             strcpy(&sys[0],rsys);
  1921.             sys[q-rsys]='\0';
  1922.             p=q+1;
  1923.             }
  1924.     }
  1925.         
  1926.     if ((!local && *fname =='\0') || (local && &sys[0]=='\0')) {
  1927.         fprintf(stdout, "null name\n");
  1928.         exit(EX_DATAERR);
  1929.     }
  1930. #ifdef DEBUG
  1931.     if (Debug>3)
  1932.         printf("p = %s sys = %s fname = %s\n",p, &sys[0],fname);
  1933. #endif
  1934.  
  1935.     if (uupath)
  1936.         {
  1937.         printf ("Path to %s:  %s\n", *av, fname);
  1938.         continue;
  1939.         }
  1940.     else
  1941.     {
  1942.         if (local)
  1943.             sprintf(cmd, LOCALMAIL, &sys[0]);
  1944.         else {
  1945.             strcpy(cmd,"uux - ");
  1946.         if (!startuux)
  1947.             strcat(cmd,"-r");
  1948. #ifndef NORETURN
  1949.         if (from)
  1950.             {
  1951.             strcat(cmd," -a");
  1952.             strcat(cmd,from);
  1953.             }
  1954. #endif
  1955. #ifndef NOGRADE
  1956.         if (grade)
  1957.             {
  1958.             char work[10];
  1959.             sprintf(work," -g%c",grade);
  1960.             strcat(cmd,work);
  1961.             }
  1962. #endif        
  1963.         if (index(p, '!'))
  1964.             {
  1965.                 char work[100];
  1966.                 sprintf(work, " %s!rmail \\(%s\\)",  &sys[0], p);
  1967.                 strcat(cmd,work);
  1968.             }
  1969.         else
  1970.             {
  1971.                 char work[100];
  1972.                 sprintf(work, " %s!rmail %s", &sys[0], p);
  1973.                 strcat(cmd,work);
  1974.             }
  1975.         }
  1976. #ifdef DEBUG
  1977.     if (Debug) fprintf(stderr,"Command is %s\n",cmd);
  1978. #endif
  1979.         rewind(tmpf);
  1980. #ifdef DEBUG
  1981.         if (Debug)
  1982.             out = fopen("UUMAIL.TEST","w");
  1983.         else
  1984. #endif
  1985.             out = popen(cmd, "w");
  1986. /*        fputs(lbuf, out); */
  1987.         if (!noheader) Putfrom(tmpf,out);
  1988.         while (fgets(lbuf, sizeof lbuf, tmpf))
  1989.             fputs(lbuf, out);
  1990.  
  1991. /* may not be needed */
  1992.         if (local)
  1993.             fprintf(out,"\n.\n");
  1994.  
  1995. #ifdef DEBUG
  1996.         if (Debug)
  1997.             i = fclose(out);
  1998.         else
  1999. #endif
  2000.             i = pclose(out);
  2001.         if ((i & 0377) != 0)
  2002.             {
  2003.                 fprintf(stderr, "pclose: status 0%o\n", i);
  2004.                 deadletter(tmpf,local);
  2005. #ifdef DEBUG
  2006.                 if (Debug <3) unlink(templet);
  2007. #endif
  2008.                 exit(EX_OSERR);
  2009.             }
  2010. #ifdef LOG
  2011.         maillog(cmd);
  2012. #endif
  2013.        }
  2014.     }
  2015. #ifdef DEBUG
  2016.     if (Debug <3) unlink(templet);
  2017. #endif
  2018. exit(EX_OK);
  2019. }
  2020.  
  2021. /* print an error message on stderr */
  2022.  
  2023. syserr(string)
  2024. char * string;
  2025. {
  2026.     fprintf(stderr,"%s\n",string);
  2027. }
  2028.  
  2029. /* make a unix type From line and send it out the stream */
  2030.  
  2031. Putfrom(into,outto)
  2032. XFILE *into, *outto;
  2033. {
  2034.     char    *asctime();
  2035.     struct    tm *bp, *localtime();
  2036.     char    *tp, *zp;
  2037.     int    n,fromflag=0;
  2038.     char buf[128];
  2039.     long iop;
  2040.  
  2041.     /*
  2042.      * Format time
  2043.      */
  2044.     time(&iop);
  2045.     bp = localtime(&iop);
  2046.     tp = asctime(bp);
  2047. /*    zp = tzname[bp->tm_isdst];*/
  2048. /*    sprintf(buf, "%s%s %.16s %.3s %.5s", from, tp, zp, tp+20);*/
  2049.     sprintf(buf, "From %s %.16s %.4s", from, tp, tp+20);
  2050.  
  2051. #ifdef UGLYUUCP
  2052.     if (!local){
  2053.             strcat(buf," remote from ");
  2054.             strcat(buf,Myname);
  2055.            }
  2056. #endif
  2057.     strcat(buf,"\n");
  2058.     write(outto->_file,buf,strlen(buf));
  2059.     fflush(outto);
  2060.  
  2061.     if (fgets(buf,sizeof(buf),into) != NULL)
  2062.     if((strncmp(&buf[0], "From ", 5) == 0 || strncmp(&buf[0], "From:", 5) == 0))
  2063.          write(outto->_file,">",1);
  2064.     
  2065.     write(outto->_file,buf,strlen(buf));
  2066. }
  2067.  
  2068.  
  2069. /* attempt to return dead letter */
  2070. /* we'll do better on this one next time */
  2071.  
  2072. deadletter(retlet, here)
  2073. XFILE *retlet;
  2074. int here;
  2075. {
  2076.     if(getlogin() != NULL) syserr("Letter failed....\n");
  2077. }
  2078.  
  2079. /* go here on a signal we want to catch */
  2080. intsig()
  2081. {
  2082.     unlink(templet);
  2083.     exit(EX_OK);
  2084. }
  2085.  
  2086. /* put command strings in the logfile */
  2087.  
  2088. #ifdef LOG
  2089.  
  2090. maillog(command)
  2091. char * command;
  2092. {
  2093.     FILE *f;
  2094.     char atime[24];
  2095.     long clock;
  2096.     time (&clock);
  2097.     strncpy(atime,ctime(&clock),24);
  2098.  
  2099.     if ((f=fopen(logfile,"a")) != NULL)
  2100.         {
  2101.             fprintf(f,"%s: %s - %s\n",progname,atime,command);
  2102.             fclose(f);
  2103.         }
  2104. }
  2105.  
  2106. #endif
  2107. SHAR_EOF
  2108. if test 11965 -ne "`wc -c < 'uumail.c'`"
  2109. then
  2110.     echo shar: error transmitting "'uumail.c'" '(should have been 11965 characters)'
  2111. fi
  2112. fi # end of overwriting check
  2113. echo shar: extracting "'uupath.1'" '(759 characters)'
  2114. if test -f 'uupath.1'
  2115. then
  2116.     echo shar: will not over-write existing file "'uupath.1'"
  2117. else
  2118. sed 's/^X//' << \SHAR_EOF > 'uupath.1'
  2119. X.TH "UUPATH" "1" "Baylor College of Medicine"
  2120. X.fi
  2121. X.ad b
  2122. X.SH NAME
  2123. uupath \- print mail routing information using uucpmap database
  2124. X.SH SYNOPSIS
  2125. X.B uupath  \fIhost1 host2 host3 ...\fR
  2126. X.SH DESCRIPTION
  2127. X.B Uupath
  2128. is designed to be used to query the uucpmap database for mail routing
  2129. paths used by
  2130. X.I uumail.
  2131. X.SS Arguments
  2132. X.IP "host1 host2 host3 ..."
  2133. where host1, host2, host3 and so on are system node names on the network.
  2134. Many hostnames may be entered as arguements to
  2135. X.I uupath.
  2136.  
  2137. X.SH FILES
  2138. X.IP "/usr/lib/uucp/palias" 
  2139. Path file produced by pathalias.
  2140. X.SH "SEE ALSO"
  2141. pathalias(1), Pnews(1), Rnmail(1), rn(1), postnews(1), readnews(1), uumail(8)
  2142.  
  2143. X.SH AUTHORS
  2144. X.br
  2145. Jeff Donnelly, University of Illinois
  2146. X.br
  2147. XStan Barber, Baylor College of Medicine & Rice University
  2148.  
  2149. SHAR_EOF
  2150. if test 759 -ne "`wc -c < 'uupath.1'`"
  2151. then
  2152.     echo shar: error transmitting "'uupath.1'" '(should have been 759 characters)'
  2153. fi
  2154. fi # end of overwriting check
  2155. echo shar: extracting "'uupath.c'" '(1155 characters)'
  2156. if test -f 'uupath.c'
  2157. then
  2158.     echo shar: will not over-write existing file "'uupath.c'"
  2159. else
  2160. sed 's/^X//' << \SHAR_EOF > 'uupath.c'
  2161. /*
  2162.  * Name: uupath
  2163.  *
  2164.  * Calls getpath to lookup the usenet path
  2165.  *
  2166.  * Author: J. Donnelly  3/82
  2167.  * $Log:    uupath.c,v $
  2168.  * Revision 1.3  85/08/03  01:26:17  UUCP
  2169.  * *** empty log message ***
  2170.  * 
  2171.  * Revision 1.2  85/07/19  17:47:05  UUCP
  2172.  * updated to define Debug for compatability with getpath
  2173.  * 
  2174.  * Revision 1.1  85/07/11  18:35:59  sob
  2175.  * Initial revision
  2176.  * 
  2177.  *
  2178.  */
  2179.  
  2180. #include    "uuconf.h"
  2181. bool Debug;
  2182.  
  2183. static char rcsid[] = "$Header: uupath.c,v 1.3 85/08/03 01:26:17 UUCP Exp $";
  2184.  
  2185. main (argc, argv) char *argv[];
  2186. {
  2187.     char    path[PATHSIZ],work[BUFSIZ];
  2188.     int     i,
  2189.             retval;                    /* value returned from getpath */
  2190.  
  2191.     if (argc < 2)
  2192.     {
  2193.     printf ("Usage: uupath sysname1 sysname2 ...\n");
  2194.     exit (EX_USAGE);
  2195.     }
  2196.  
  2197.     for (i = 1; i < argc; i++)
  2198.     {
  2199.     retval = getpath (argv[i], &path[0],DATABASE);        /* lookup usenet path */
  2200.     if (retval == EX_NOHOST)
  2201.         printf ("Can't find path to %s\n", argv[i]);
  2202.  
  2203.     else
  2204.         if (retval == EX_NOINPUT)
  2205.         {
  2206.         printf ("Can't open the network map\n");
  2207.         exit (EX_TEMPFAIL);
  2208.         }
  2209.  
  2210.         else
  2211.         {
  2212.         sprintf (&work[0],"Path to %s:  %s\n", argv[i], &path[0]);
  2213.             printf(&work[0],"username");
  2214.         }
  2215.     }
  2216. }
  2217. SHAR_EOF
  2218. if test 1155 -ne "`wc -c < 'uupath.c'`"
  2219. then
  2220.     echo shar: error transmitting "'uupath.c'" '(should have been 1155 characters)'
  2221. fi
  2222. fi # end of overwriting check
  2223. #    End of shell archive
  2224. exit 0
  2225.  
  2226.